package com.xbongbong.pro.service.toolbox.statistic.help;

import com.xbongbong.i18n.util.I18nMessageUtil;
import com.xbongbong.paas.constant.TimeConstant;
import com.xbongbong.paas.toolbox.util.DateUtil;
import com.xbongbong.paas.toolbox.util.StringUtil;
import com.xbongbong.pro.constant.CommonConstant;
import com.xbongbong.pro.constant.I18nStringConstant;
import com.xbongbong.pro.enums.TimeTypeEnum;
import com.xbongbong.pro.statistic.pojo.FiscalYearTimePojo;
import com.xbongbong.pro.statistic.result.pojo.TimeListPojo;

import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.*;


/**
 * 该方法用于处理财年相关时间
 * 注：
 * （1）对于筛选近期、某月，保持不变（按照自然年即可）；
 * （2）全年：按照设置的财年起止时间计算；
 * （3）上下半年：按照财年的前6个月和财年的后6个月；
 * （4）季度：财年的前3个月为第一季度，第4到第6个月为第二个季度，以此类推。
 * @author zcp
 * @date 2019/2/13 14:44
 * @since v1.0
 * @version v1.0
 */
public class FiscalYearHelp {

    /**
     * 目标管理内 “设置财年”弹出框的“财年周期”提示语
     *
     * @param startMonth 财年起始月
     * @return 财年周期，例：“7月1日至次年6月30日”
     * @since 3.9
     * @version
     * @author cp.zhang
     * 创建时间：2017-7-11 上午10:53:13
     * 修改时间：
     */
    public static String getLableFiscalYear(int startMonth, String year) {
        //截止月份
        int endMonth = (startMonth - 1 == 0) ? 12 : startMonth - 1;
        //		int endDay = getEndMonthDay(startMonth, endMonth, year);//结束日
        String flag = (endMonth == 12)? I18nMessageUtil.getMessage(CommonConstant.THIS_YEAR): I18nMessageUtil.getMessage(CommonConstant.FOLLOWING_YEAR);
        //		String lableFiscalYear = startMonth + "月1日至" + flag + endMonth + "月"+ endDay +"日";
        return startMonth + I18nMessageUtil.getMessage(I18nStringConstant.MONTH_TO) + flag + endMonth + I18nMessageUtil.getMessage(CommonConstant.MONTH);
    }

    /**
     * 计算财年开始时间 返回int时间戳
     * @param fiscalYear 筛选哪一个财年
     * @param startMonth 财年起始月，默认按照该月1日
     * @return int 财年开始时间戳
     * @author zcp
     * @date 2019/2/13 16:15
     * @since v1.0
     * @version v1.0
     */
    public static int getFiscalYearStartInt(Integer fiscalYear, int startMonth) {
        return DateUtil.getInt(getFiscalYearStartStr(fiscalYear + "", startMonth), new SimpleDateFormat("yyyy-MM-dd"));
    }

    /**
     * 计算财年的结束，得到结束的int时间戳
     * @param fiscalYear 筛选哪一个财年
     * @param startMonth 财年起始月
     * @return int 财年结束时间戳
     * @author zcp
     * @date 2019/2/13 16:16
     * @since v1.0
     * @version v1.0
     */
    public static int getFiscalYearEndInt(Integer fiscalYear, int startMonth) {
        if (fiscalYear == null || 0 == fiscalYear) {
            //不传则默认本财年，规则：结束月份所在的月份即当前财年年份
            fiscalYear = DateUtil.getYear4Someday(DateUtil.getInt());
            if (startMonth != 1) {
                //财年起始月不为1月，则year财年为自然年+1
                fiscalYear += 1;
            }
        }
        /*
          财年结束是下年度startMonth的1号
          如，
          startMonth = 1时，2019财年起始为“2019-1-1”对应的0点时间戳，2019财年结束为“2020-1-1”对应的0点时间戳
          startMonth = 3时，2019财年起始为“2018-3-1”对应的0点时间戳，2019财年结束为“2019-3-1”对应的0点时间戳
         */
        int year = (startMonth == 1) ? (fiscalYear + 1) : fiscalYear;
        String day = year + "-" + startMonth + "-1";
        return DateUtil.getInt(day, new SimpleDateFormat("yyyy-MM-dd"));
    }

    /**
     * 获取某周期开始时间
     * 注：timeType和fromType的关系
     * timeType:查看的业务的时间范围类型
     * fromType:点折线图内的某个数据时，如果大的时间范围是“年”，则图内单个数据展示的是“某月”；如果筛选的是“月/周”，则单个数据展示的是“某日”
     * 比如，筛选了3月的数据，然后点击了表格内3月8日的数据，则穿透时，timeType=1（代表日,结合month=3,day=8算具体时间）、fromType=3（筛选了月）
     * @param fiscalYearTimePojo 封装了fromType、year、season、month、weekIndex、day、startTime、endTime等参数
     * @param timeType           周期类型  比如：5年、4季、3月、2周、1日--有对应枚举TimeTypeEnum
     * @param startMonth         财年开始月，没设置，则该值为1
     * @return java.lang.Integer 开始时间
     * @author zcp
     * @date 2019/2/13 16:18
     * @since v1.0
     * @version v1.0
     */
    public static Integer getStartTime(FiscalYearTimePojo fiscalYearTimePojo, Integer timeType, int startMonth) {
        /*
          timeType:查看的业务的时间范围类型
          fromType:点折线图内的某个数据时，如果大的时间范围是“年”，则图内单个数据展示的是“某月”；如果筛选的是“月/周”，则单个数据展示的是“某日”
          比如，筛选了3月的数据，然后点击了表格内3月8日的数据，则穿透时，timeType=1（代表日,结合month=3,day=8算具体时间）、fromType=3（筛选了月）
         */
        Integer fromType = fiscalYearTimePojo.getFromType();
        Integer year = fiscalYearTimePojo.getYear();
        Integer season = fiscalYearTimePojo.getSeason();
        Integer month = fiscalYearTimePojo.getMonth();
        Integer weekIndex = fiscalYearTimePojo.getWeekIndex();
        String startTimeStr = fiscalYearTimePojo.getStartTime();
        Integer startTime = 0;
        TimeTypeEnum timeTypeEnum = TimeTypeEnum.getByCode(timeType);
        switch (timeTypeEnum) {
            //全年、上半年 开始时间一样
            case YEAR:
            case YEAR_HALF_UP:
                startTime = getFiscalYearStartInt(year, startMonth);
                break;
            //下半年
            case YEAR_HALF_DOWN:
                startTime = getFirstDate4Fiscal(year, startMonth, startMonth + 6);
                break;
            //季度
            case SEASON:
                //季度值为0，则获取到当前时间在财年的第几个季度
                if (season == 0) {
                    Integer now = DateUtil.getInt();
                    //当前时间在财年周期属于第几个季度
                    season = DateUtil.getSeason4Fiscal(now, startMonth);
                    //判断当前月份（即当前季度）所在的财年年份
                    int nowMonth = DateUtil.getMonth4Someday(now);
                    year = DateUtil.getFiscalYearByMonth(year, nowMonth, startMonth);
                }
                int beginMonth = startMonth + (season - 1) * 3;
                startTime = getFirstDate4Fiscal(year, startMonth, beginMonth);
                break;
            //本月，某一月---//某年某月
            case MONTH:
                year = formatYear4FromType(fromType, startMonth, year);
                //某年的第一天
                Integer someday = getSomeDayOfYear(year);
                startTime = getFirstDateOfMonth(month, someday);
                break;
            case MONTH_LAST:
                startTime = DateUtil.getFirstDateOfLastMonth();
                break;
            //周
            case WEEK:
                startTime = DateUtil.getThisWeekMorning();
                if (weekIndex > 0) {
                    startTime += (weekIndex - 1) * 86400;
                }
                break;
            case WEEK_LAST:
                startTime = DateUtil.getThisWeekMorning() - 7 * 24 * 3600;
                if (weekIndex > 0) {
                    startTime += (weekIndex - 1) * 86400;
                }
                break;
            //本日or某一日
            case DAY:
                startTime = getSomeDay(fiscalYearTimePojo.getDay(), year, fromType, month);
                break;
            case DAY_LAST:
                startTime = DateUtil.getTodayInt() - 24 * 3600;
                break;
            //自定义---自己选择开始结束时间
            case CUSTOM:
                if (!StringUtil.isEmpty(startTimeStr)) {
                    startTime = DateUtil.getInt(startTimeStr, new SimpleDateFormat("yyyy-MM-dd"));
                }
                break;
            //至今---不用设置起始时间（fix：改为近一年，统计过去365天的数据）
            case UP_TO_NOW:
                startTime = DateUtil.getPastYear();
                break;
            //自定义动态
            case DYNAMIC:
                LocalDateTime rightNow = LocalDateTime.now();
                //中间的数字
                long midNum = 0L;
                if (startTimeStr.length() == 4) {
                    midNum = Long.valueOf(startTimeStr.substring(2, 3));
                }
                if (startTimeStr.length() == 5) {
                    midNum = Long.valueOf(startTimeStr.substring(2, 4));
                }
                String sufTime = startTimeStr.substring(startTimeStr.length() - 1);

                if (startTimeStr.startsWith("过去")) {
                    switch (sufTime) {
                        case "天":
                            startTimeStr = rightNow.minusDays(midNum).toLocalDate().toString();
                            startTime = DateUtil.getInt(startTimeStr, new SimpleDateFormat("yyyy-MM-dd"));
                           // startTime += 86400;
                            break;
                        case "周":
                            startTime = DateUtil.getThisWeekMorning() - (int)midNum  * 7 * 24 * 3600;
                            break;
                        case "月":
                            startTime = DateUtil.getFirstDateOfLastMonth() - ((int)midNum -1) * 30 * 86400;
                            break;
                    }
                } else if (startTimeStr.startsWith("当前")) {
                    switch (sufTime) {
                        case "天":
                            startTimeStr = rightNow.toLocalDate().toString();
                            startTime = DateUtil.getInt(startTimeStr, new SimpleDateFormat("yyyy-MM-dd"));
                            break;
                        case "周":
                            startTime = getStartTime(fiscalYearTimePojo, 2, startMonth);
                            break;
                        case "月":
                            startTime = getStartTime(fiscalYearTimePojo, 3, startMonth);
                            break;
                    }
                } else if (startTimeStr.startsWith("未来")) {
                    switch (sufTime) {
                        case "天":
                            startTimeStr = rightNow.plusDays(midNum).toLocalDate().toString();
                            startTime = DateUtil.getInt(startTimeStr, new SimpleDateFormat("yyyy-MM-dd"));
                            //startTime += 86400;
                            break;
                        case "周":
                            startTime = DateUtil.getThisWeekMorning() + (int)midNum  * 7 * 24 * 3600;
                            break;
                        case "月":
                            startTime = DateUtil.getLastDateOfThisMonth() +((int)midNum - 1) * 30 * 86400;
                            //startTime += 86400;
                            break;
                    }
                }
                break;
            default:
                break;
        }
        return startTime;
    }

    /**
     * 获取某周期开始时间
     * 注：timeType和fromType的关系
     * timeType:查看的业务的时间范围类型
     * fromType:点折线图内的某个数据时，如果大的时间范围是“年”，则图内单个数据展示的是“某月”；如果筛选的是“月/周”，则单个数据展示的是“某日”
     * 比如，筛选了3月的数据，然后点击了表格内3月8日的数据，则穿透时，timeType=1（代表日,结合month=3,day=8算具体时间）、fromType=3（筛选了月）
     * @param fiscalYearTimePojo 封装了fromType、year、season、month、weekIndex、day、startTime、endTime等参数
     * @param startTime          开始时间
     * @param timeType           周期类型  比如：5年、4季、3月、2周、1日--有对应枚举TimeTypeEnum
     * @param startMonth         财年开始月，没设置，则该值为1
     * @return java.lang.Integer 结束时间
     * @author zcp
     * @date 2019/2/13 16:52
     * @since v1.0
     * @version v1.0
     */
    public static Integer getEndTime(FiscalYearTimePojo fiscalYearTimePojo, Integer startTime, Integer timeType, int startMonth) {
        Integer fromType = fiscalYearTimePojo.getFromType();
        Integer year = fiscalYearTimePojo.getYear();
        //本周或上周的 第几天
        Integer weekIndex = fiscalYearTimePojo.getWeekIndex();
        Integer month = fiscalYearTimePojo.getMonth();
        Integer season = fiscalYearTimePojo.getSeason();
        //string格式，获取自定义endTime--“2017-3-9”
        String endTimeStr = fiscalYearTimePojo.getEndTime();
        String startTimeStr = fiscalYearTimePojo.getStartTime();
        Integer endTime = 0;
        TimeTypeEnum timeTypeEnum = TimeTypeEnum.getByCode(timeType);
        switch (timeTypeEnum) {
            //全年、下半年 结束时间一样
            case YEAR:
            case YEAR_HALF_DOWN:
                endTime = getFiscalYearEndInt(year, startMonth);
                break;
            //上半年 结束，即下半年的起始
            case YEAR_HALF_UP:
                endTime = getFirstDate4Fiscal(year, startMonth, startMonth + 6);
                break;
            //季度
            case SEASON:
                //季度值为0，则获取到当前时间在财年的第几个季度
                if (season == 0) {
                    Integer now = DateUtil.getInt();
                    int nowMonth = DateUtil.getMonth4Someday(now);
                    year = DateUtil.getFiscalYearByMonth(year, nowMonth, startMonth);
                    season = DateUtil.getSeason4Fiscal(now, startMonth);
                }
                int beginMonth = startMonth + season * 3;
                endTime = getFirstDate4Fiscal(year, startMonth, beginMonth);
                break;
            //本月，某一月---//某年某月
            case MONTH:
                year = formatYear4FromType(fromType, startMonth, year);
                //某年的第一天，最后一天就变为下年了（下年0点）
                Integer someday = getSomeDayOfYear(year);
                endTime = getEndDateOfMonth(month, someday);
                break;
            //上月
            case MONTH_LAST:
                //上月结束，即本月开始
                endTime = DateUtil.getFirstDateOfThisMonth();
                break;
            //本周，某周，上周的endTime--用startTime即可算得
            case WEEK:
            case WEEK_LAST:
                endTime = startTime + 7 * 86400;
                //如果是筛选该周的第几天，则endTime对startTime +86400即可
                if (weekIndex > 0) {
                    endTime = startTime + 86400;
                }
                break;
            //今日，某日，昨日的endTime--用startTime即可算得
            case DAY:
            case DAY_LAST:
                endTime = startTime + 86400;
                break;
            //自定义---自己选择开始结束时间
            case CUSTOM:
                //自定义endTime
                if (!StringUtil.isEmpty(endTimeStr)) {
                    endTime = DateUtil.getInt(endTimeStr, new SimpleDateFormat("yyyy-MM-dd"));
                    //截至当天0点
                    endTime += 86400;
                }
                break;
            //至今---设置endTime为当前时间startTime为0
            case UP_TO_NOW:
//                endTimeStr = LocalDateTime.now().toLocalDate().toString();
//                endTime = DateUtil.getInt(endTimeStr, new SimpleDateFormat("yyyy-MM-dd"));
//                endTime += 86400;
                  endTime = (int)DateUtil.getNow();
                break;
            //自定义动态
            case DYNAMIC:
                //起始时间后缀
                String sufStartTime = startTimeStr.substring(startTimeStr.length() - 1);
                //结束时间后缀
                String sufEndTime = endTimeStr.substring(endTimeStr.length() - 1);
                //判断是否合理
                if ((startTimeStr.startsWith("当前")) && (endTimeStr.startsWith("过去"))){
                        break;
                }
                //当前时间对象
                LocalDateTime rightNow = LocalDateTime.now();
                //中间的数字
                long midNum = 0L;
                if (endTimeStr.length() == 4) {
                    midNum = Long.valueOf(endTimeStr.substring(2, 3));
                }
                if (endTimeStr.length() == 5) {
                    midNum = Long.valueOf(endTimeStr.substring(2, 4));
                }
                if (endTimeStr.startsWith("过去")) {
                    switch (sufEndTime) {
                        case "天":
                            endTimeStr = rightNow.minusDays(midNum).toLocalDate().toString();
                            endTime = DateUtil.getInt(endTimeStr, new SimpleDateFormat("yyyy-MM-dd"));
                            endTime += 86400;
                            break;
                        case "周":
                            endTime = DateUtil.getThisWeekMorning() - ((int)midNum - 1) * 7 * 24 * 3600;
                            break;
                        case "月":
                            endTime = DateUtil.getFirstDateOfThisMonth() - ((int)midNum - 1)  * 30 * 86400;
                            break;
                    }
                } else if (endTimeStr.startsWith("当前")) {
                    switch (sufEndTime) {
                        case "天":
                            endTimeStr = rightNow.toLocalDate().toString();
                            endTime += DateUtil.getInt(endTimeStr, new SimpleDateFormat("yyyy-MM-dd"));
                            endTime += 86400;
                            break;
                        case "周":
                            endTime = DateUtil.getThisWeekMorning()+ 7 * 24 * 3600;
                            break;
                        case "月":
                            endTime = DateUtil.getLastDateOfThisMonth();
                            break;
                    }
                } else if (endTimeStr.startsWith("未来")) {
                    switch (sufEndTime) {
                        case "天":
                            endTimeStr = rightNow.plusDays(midNum).toLocalDate().toString();
                            endTime += DateUtil.getInt(endTimeStr, new SimpleDateFormat("yyyy-MM-dd"));
                            endTime += 86400;
                            break;
                        case "周":
                            endTime = DateUtil.getThisWeekMorning() + ((int)midNum + 1) * 7 * 24 * 3600;
                            break;
                        case "月":
                            endTime = DateUtil.getLastDateOfThisMonth() +(int)midNum  * 30 * 86400;
                            break;
                    }
                }
                break;
            default:
                break;
        }
        return endTime;
    }

    /**
     * 获取每个月or月内的每天or周内每天。。。的开始结束时间list、和结束时间list
     * @param fiscalYearTimePojo             封装了fromType、year、season、month、weekIndex、day、startTime、endTime等参数
     * @param timeType--对应枚举TimeTypeEnum的年、季
     * @param flag                           0正常的获取开始时间，1代表截至到某个时间、没有限定开始时间
     *                                       注：flag默认为0，只有特殊的统计才是1，比如“客户总数分析”（截至当前时间）。。目前只有客户总数的该值是1
     * @param startMonth                     财年开始月份
     * @return com.xbongbong.pro.statistic.pojo.TimeListPojo
     * @author zcp
     * @date 2019/2/13 20:37
     * @since v1.0
     * @version v1.0
     */
    public static TimeListPojo getTimeList(FiscalYearTimePojo fiscalYearTimePojo, Integer timeType, Integer flag, int startMonth) {
        Integer year = fiscalYearTimePojo.getYear();
        TimeListPojo timeListPojo = new TimeListPojo();
        List<Integer> startTimeList = timeListPojo.getStartTimeList();
        List<Integer> endTimeList = timeListPojo.getEndTimeList();
        TimeTypeEnum timeTypeEnum = TimeTypeEnum.getByCode(timeType);
        switch (timeTypeEnum) {
            case YEAR:
                formatTime2Month(startTimeList, endTimeList, flag, year, startMonth, startMonth, 12);
                break;
            case YEAR_HALF_UP:
                formatTime2Month(startTimeList, endTimeList, flag, year, startMonth, startMonth, 6);
                break;
            case YEAR_HALF_DOWN:
                //下半年+6
                formatTime2Month(startTimeList, endTimeList, flag, year, startMonth, startMonth + 6, 6);
                break;
            case SEASON:
                //季度按季度，遍历3次
                Integer season = fiscalYearTimePojo.getSeason();
                if (season == 0) {
                    Integer now = DateUtil.getInt();
                    //当前月份
                    Integer month = DateUtil.getMonth4Someday(now);
                    //判断当前月份所在的财年年份
                    year = DateUtil.getFiscalYearByMonth(year, month, startMonth);
                    ;
                    season = DateUtil.getSeason4Fiscal(now, startMonth);
                }
                //第season季度的起始月份
                int beginMonth = startMonth + (season - 1) * 3;
                formatTime2Month(startTimeList, endTimeList, flag, year, startMonth, beginMonth, 3);
                break;
            //月、上月---//月转换为日
            case MONTH:
            case MONTH_LAST:
                Integer monthStartTime = getStartTime(fiscalYearTimePojo, timeType, startMonth);
                Integer monthEndTime = getEndTime(fiscalYearTimePojo, monthStartTime, timeType, startMonth);
                //按月，切分成天
                Integer size = (monthEndTime - monthStartTime) / 86400;
                formatTime2Day(startTimeList, endTimeList, flag, monthStartTime, size);
                break;
            case WEEK:
            case WEEK_LAST:
                //周初--上周初or本周初
                Integer tempStartTime = getStartTime(fiscalYearTimePojo, timeType, startMonth);
                formatTime2Day(startTimeList, endTimeList, flag, tempStartTime, 7);
                break;
            case DAY:
            case DAY_LAST:
                Integer todayInt = DateUtil.getTodayInt();
                Integer startTime = (timeType.equals(TimeTypeEnum.DAY.getCode())) ? todayInt : todayInt - 86400;
                formatTime2Day(startTimeList, endTimeList, flag, startTime, 1);
                break;
            //自定义
            case CUSTOM:
                startTime = getStartTime(fiscalYearTimePojo, timeType, startMonth);
                Integer endTime = getEndTime(fiscalYearTimePojo, startTime, timeType, startMonth);
                if (startTime == 0 && endTime == 0) {
                    //两个都没传，则默认当天
                    startTime = DateUtil.getTodayInt();
                    endTime = startTime + 86400;
                } else if (startTime == 0) {
                    //只传了结束时间，则默认筛选的是一天的时间
                    startTime = endTime - 86400;
                } else if (endTime == 0) {
                    //只传了开始时间，则默认筛选的是一天的时间
                    endTime = startTime + 86400;
                }
                startTimeList.add(startTime);
                endTimeList.add(endTime);
                break;
            case UP_TO_NOW:
            case DYNAMIC:
                startTime = getStartTime(fiscalYearTimePojo, timeType, startMonth);
                endTime = getEndTime(fiscalYearTimePojo, startTime, timeType, startMonth);
                startTimeList.add(startTime);
                endTimeList.add(endTime);
                break;
            default:
                break;
        }
        //开始结束时间，肯定相等
        return timeListPojo;
    }

    /**
     * 得到时间标题---传入的是fiscalYearTimePojo，先计算出timeListPojo
     * @param fiscalYearTimePojo             封装了fromType、year、season、month、weekIndex、day、startTime、endTime等参数
     * @param timeType--对应枚举TimeTypeEnum的年、季
     * @param startMonth                     财年开始月份
     * @return java.util.List<java.lang.String> 坐标轴时间标题
     * @author zcp
     * @date 2019/2/18 16:46
     * @since v1.0
     * @version v1.0
     */
    public static List<String> getDateTitleList(FiscalYearTimePojo fiscalYearTimePojo, Integer timeType, int startMonth) {
        //计算startTimeList、endTimeList
        TimeListPojo timeListPojo = FiscalYearHelp.getTimeList(fiscalYearTimePojo, timeType, 0, startMonth);
        return getDateTitleList(timeListPojo, timeType, startMonth);
    }

    /**
     * 得到时间标题
     * @param timeListPojo                   开始、结束时间list
     * @param timeType--对应枚举TimeTypeEnum的年、季
     * @param startMonth                     财年开始月份
     * @return java.util.List<java.lang.String> 坐标轴时间标题
     * @author zcp
     * @date 2019/2/15 09:32
     * @since v1.0
     * @version v1.0
     */
    public static List<String> getDateTitleList(TimeListPojo timeListPojo, Integer timeType, int startMonth) {
        List<String> dateTitleList = new ArrayList<>();
        if (timeListPojo == null) {
            return dateTitleList;
        }
        List<Integer> startTimeList = timeListPojo.getStartTimeList();
        List<Integer> endTimeList = timeListPojo.getEndTimeList();
        TimeTypeEnum timeTypeEnum = TimeTypeEnum.getByCode(timeType);
        switch (timeTypeEnum) {
            case YEAR:
            case YEAR_HALF_UP:
            case YEAR_HALF_DOWN:
            case SEASON:
                for (Integer time : startTimeList) {
                    dateTitleList.add(DateUtil.getString(time, new SimpleDateFormat("yyyy-MM")));
                }
                break;
            case MONTH:
            case MONTH_LAST:
                for (Integer time : startTimeList) {
                    dateTitleList.add(DateUtil.getString(time, new SimpleDateFormat(I18nMessageUtil.getMessage(I18nStringConstant.D_DAY))));
                }
                break;
            case WEEK:
            case WEEK_LAST:
            case DAY:
            case DAY_LAST:
                for (Integer time : startTimeList) {
                    dateTitleList.add(DateUtil.getString(time, new SimpleDateFormat(I18nMessageUtil.getMessage(I18nStringConstant.M_MONTH_D_DAY))));
                }
                break;
            case CUSTOM:
            case UP_TO_NOW:
            case DYNAMIC:
                if (startTimeList.size() > 0 && endTimeList.size() > 0) {
                    Integer startTime = startTimeList.get(0);
                    Integer endTime = endTimeList.get(0);
                    String startTimeStr = DateUtil.getString(startTime, new SimpleDateFormat("yyyy-MM-dd"));
                    if (Objects.equals(startTime, endTime)) {
                        //同一天
                        dateTitleList.add(startTimeStr);
                    } else {
                        //自定义时间区间
                        //endTime - 1处理显示的日期为后一天0点的问题
                        String endTimeStr = DateUtil.getString(endTime - 1, new SimpleDateFormat("yyyy-MM-dd"));
                        dateTitleList.add(startTimeStr + I18nMessageUtil.getMessage(CommonConstant.TO) + endTimeStr);
                    }
                }
                break;
            default:
                break;
        }
        return dateTitleList;
    }

    /**
     * 获取某月的所有周
     *
     * @param fiscalYear 财年
     * @param year       自然年
     * @param month      自然月
     * @param startMonth 财年起始月
     * @return Map，周索引--区间，比如key="w1"，value="07-02至07-08"
     * @since performance-v1.0
     * @version performance-v1.0
     * @author cp.zhang
     * 创建时间：2018年8月3日 上午9:25:41
     * 修改时间：
     */
    public static Map<String, String> getWeekMap4Month(Integer fiscalYear, Integer year, Integer month, int startMonth) {
        /**
         * 计算year年month月份的开始、结束时间
         */
        Integer startStr = DateUtil.getInt(year + "-" + month + "-" + "1", new SimpleDateFormat("yyyy-MM-dd"));
        Integer monthStart = DateUtil.getFirstDateOfMonthInSomeday(startStr);
        Integer monthEnd = DateUtil.getLastDateOfMonthInSomeday(startStr);
        //获取财年的起始月份的int时间戳
        Integer fiscalStartTime = FiscalYearHelp.getFiscalYearStartInt(fiscalYear, startMonth);
        /*********************封装周数据：只获取month月内的几个周*********************/
        //month月的第一个周(也可能不在该月)
        Integer weekNum4Start = DateUtil.getWeekNum(fiscalStartTime, monthStart);
        //month月的最后一个周
        Integer weekNum4End = DateUtil.getWeekNum(fiscalStartTime, monthEnd);
        //第weekNum4Start周的周一0点的时间
        Integer weekStartTime4Start = DateUtil.getWeekStartTime(fiscalStartTime, weekNum4Start);
        Integer weekStartTime4End = DateUtil.getWeekStartTime(fiscalStartTime, weekNum4End);
        //只获取month月的周，固不在本财年的不考虑（排除负数情况，即排除上财年的情况）
//        weekNum4Start = (weekNum4Start < 0)? 0: weekNum4Start;
        int weekNum4StartTemp = (weekNum4Start < 0) ? 0 : weekNum4Start;
        //第weekNum4Start周的周一0点的时间不在该月，说明month月的第一个周是不属于该month的，后推一周
        if (weekStartTime4Start < monthStart) {
            //因为按照【周一在当前月份，则当周归属为该月，否则则归属到上一个月】的原则，第weekNum4Start周是属于month的上一个月的，往后平移一周
            weekStartTime4Start += 7 * 24 * 3600;
            weekNum4StartTemp++;
        }
        Integer weekTime = 7 * 24 * 3600;
        //周索引--区间，比如key="w1"，value="07-02至07-08"
        Map<String, String> weekPeriodMap = new LinkedHashMap<>();
        for (Integer time = weekStartTime4Start; time <= weekStartTime4End; ) {
            //标题："07-02至07-08", "07-09至07-15", ...
            //该周开始
            String title = DateUtil.getString(time, DateUtil.SDFMonthDay);
            //该周结束（因时间戳的截止时间是获取的下周一的0点，转化为string时要减一处理）
            time += weekTime - 1;
            title += I18nMessageUtil.getMessage(CommonConstant.TO) + DateUtil.getString(time, DateUtil.SDFMonthDay);
            String key = "w" + weekNum4StartTemp;

            weekPeriodMap.put(key, title);
            //把减的1加回去
            time += 1;
            //下一周
            weekNum4StartTemp++;
        }
        return weekPeriodMap;
    }

    /**
     * 判断筛选维度所在的财年年份（因为像今日、昨日、本周、上周、本季度这些，都是自然年的时间，是需要判断这个时间在哪个财年年份的）
     * @param timeTypeEnum       时间枚举
     * @param fiscalYearTimePojo 筛选pojo
     * @param startTime          筛选开始时间
     * @param endTime            筛选结束时间
     * @return
     * @throws
     *
     * @author hongxiao
     * @date: 2019-02-20 16:49
     * @since v1.0
     * @version v1.0
     */
    public static Integer dealWithFiscalYear(TimeTypeEnum timeTypeEnum, FiscalYearTimePojo fiscalYearTimePojo, Integer startTime,
                                             Integer endTime) {
        Integer year = fiscalYearTimePojo.getYear();
        Integer startMonth = fiscalYearTimePojo.getStartMonth();
        Integer fiscalYear = year;
        /*
         * 把可能跨财年的，计算出来其所在财年
         */
        switch (timeTypeEnum) {
            case DAY:
            case DAY_LAST:
            case MONTH:
            case MONTH_LAST:
                //筛选的开始时间所在的月份（自然月）
                Integer someMonth = DateUtil.getMonth4Someday(startTime);
                //判断someMonth所在的财年年份：处理之前，fiscalYear是自然年，需根据财年起始月结合someMonth处理year
                fiscalYear = DateUtil.getFiscalYearByMonth(year, someMonth, startMonth);
                //把自然月份处理成财年月份
                Integer fiscalMonth = DateUtil.getFiscalMonth(startMonth, someMonth);
                //把月份置为相应的财年的第几个月份
                fiscalYearTimePojo.setMonth(fiscalMonth);
                break;
            case SEASON:
                Integer season = fiscalYearTimePojo.getSeason();
                if (season == 0) {
                    Integer now = DateUtil.getInt();
                    //当前月份
                    Integer month = DateUtil.getMonth4Someday(now);
                    //判断当前月份所在的财年年份
                    fiscalYear = DateUtil.getFiscalYearByMonth(year, month, startMonth);
                    season = DateUtil.getSeason4Fiscal(now, startMonth);
                    //把季度索引置入
                    fiscalYearTimePojo.setSeason(season);
                }
                break;
            case WEEK:
                /*
                 * 筛选周的，有一个规则需要考虑在内：【如果周一在当前月份，则当周归属为该月，否则则归属到上一个月】
                 * 也就是说，存在这样的情况：筛选的时间是在本财年，但是按照规则却是属于上一财年的目标
                 * 所以，根据规则，可以判断本周是不是在本月（再判断周所在月份的财年年份）
                 */
                Integer weekStart = DateUtil.getThisWeekMorning();
                Integer thisMonthStart = DateUtil.getFirstDateOfThisMonth();
                //判断当周在本月还是上月
                if (weekStart < thisMonthStart) {
                    //周一不在本月，则说明本周属于上月
                    someMonth = DateUtil.getMonth4Someday(thisMonthStart - TimeConstant.SECONDS_PER_DAY);
                } else {
                    someMonth = DateUtil.getMonth4Someday(thisMonthStart);
                }
                fiscalYear = DateUtil.getFiscalYearByMonth(year, someMonth, startMonth);
                fiscalMonth = DateUtil.getFiscalMonth(startMonth, someMonth);
                fiscalYearTimePojo.setMonth(fiscalMonth);
                break;
            case WEEK_LAST:
                //上周
                weekStart = DateUtil.getThisWeekMorning() - TimeConstant.SECONDS_PER_WEEK;
                thisMonthStart = DateUtil.getFirstDateOfThisMonth();
                //判断上周在本月还是上月
                if (weekStart < thisMonthStart) {
                    //周一不在本月，则说明上周属于上月
                    someMonth = DateUtil.getMonth4Someday(thisMonthStart - TimeConstant.SECONDS_PER_DAY);
                } else {
                    someMonth = DateUtil.getMonth4Someday(thisMonthStart);
                }
                //判断someMonth所在的财年年份：处理之前，fiscalYear是自然年，需根据财年起始月结合someMonth处理year
                fiscalYear = DateUtil.getFiscalYearByMonth(year, someMonth, startMonth);
                //把自然月份处理成财年月份
                fiscalMonth = DateUtil.getFiscalMonth(startMonth, someMonth);
                //把月份置为相应的财年的第几个月份
                fiscalYearTimePojo.setMonth(fiscalMonth);
                break;

            default:
                break;
        }
        fiscalYearTimePojo.setYear(fiscalYear);
        return fiscalYear;
    }

    /**
     * @param fiscalYear 筛选哪一个财年
     * @param startMonth 财年起始月，默认按照该月1日
     * @return java.lang.String 财年开始日期 如 2017-7-1
     * @author zcp
     * @date 2019/2/13 16:16
     * @since v1.0
     * @version v1.0
     */
    private static String getFiscalYearStartStr(String fiscalYear, int startMonth) {
        //防止year传入异常
        String errorYear = "0";
        if (StringUtil.isEmpty(fiscalYear) || errorYear.equals(fiscalYear)) {
            //不传则为当前月所在的财年
            fiscalYear = DateUtil.getFiscalYear4Now(startMonth) + "";
        }
        if (startMonth != 1) {
            /**
             * 因现有规则是：财年结束月所在的年份即财年年份
             * 因此：财年其实月份只要不为1月，那实际的自然年份是比财年少1的，即：财年【fiscalYear = 自然年 + 1】，也就是【自然年 = fiscalYear - 1】
             */
            Integer yearInt = StringUtil.toInt(fiscalYear);
            fiscalYear = (yearInt - 1) + "";
        }
        return fiscalYear + "-" + startMonth + "-1";
    }

    /**
     * 计算财年的结束（只是显示用，返回字符串，如2018-6-30）
     * @param fiscalYear 筛选哪一个财年
     * @param startMonth 财年起始月
     * @return java.lang.String 财年结束日期 如 2018-6-30
     * @author zcp
     * @date 2019/2/13 16:17
     * @since v1.0
     * @version v1.0
     */
    private static String getFiscalYearEndStr(String fiscalYear, int startMonth) {
        //结束为下一天的0点，所以肯定是startMonth的1号
        Integer yearInt = StringUtil.toInt(fiscalYear);
        //先调用getFiscalYearEndInt，得到结束的时间戳
        Integer endTime = getFiscalYearEndInt(yearInt, startMonth);
        //结束的时间戳是下一天的0点，因此算字符串的日期，则减去一天
        String endDay = DateUtil.getString(endTime - 86400, new SimpleDateFormat("yyyy-MM-dd"));
        return endDay;
    }

    /**
     * 获取某一个季度、下半年的第一个月的1日0点
     * @param year       年
     * @param startMonth 财年开始月
     * @param beginMonth 筛选的时间维度的开始月，例全年、上半年从1月开始；下半年从7月开始；财年3月起始月，则财年下半年的起始月为9月
     *                   下半年：beginMonth = startMonth + 6;//下半年 第7个月开始
     *                   某一季：beginMonth = startMonth + (season - 1)* 3;//第season季度开始月
     * @return int 开始时间戳
     * @author zcp
     * @date 2019/2/13 17:22
     * @since v1.0
     * @version v1.0
     */
    private static int getFirstDate4Fiscal(Integer year, int startMonth, int beginMonth) {
        if (year == 0) {
            //本年
            year = DateUtil.getYear4Someday(DateUtil.getInt());
        }
        //财年起始月不为1月，则year财年为自然年+1，因此此时自然年是year-1
        int yearTemp = (startMonth != 1) ? (year - 1) : year;
        //但是，有的时间点可能处于自然年的下一个年度，比如财年起始月为11月，那下半年的开始时间肯定在下一个年度
        if (checkIfSpanYear(beginMonth, startMonth)) {
            yearTemp++;
        }
        //如果大于12，则%12
        beginMonth = (beginMonth > 12) ? beginMonth % 12 : beginMonth;
        String start = yearTemp + "-" + beginMonth + "-01";
        return DateUtil.getInt(start, new SimpleDateFormat("yyyy-MM-dd"));
    }

    /**
     * 判断当前月是否跨年（例，2017财年起始月为7月，如果查看的是6月，则代表2018年6月，即6月是18年的 相对与17年多了1）
     * 该方法只用于 全年、上下半年、季度的计算（因为只有这几种是按照财年，其他近期or某月是按照自然年筛选的，无需这个判断）
     * 以及筛选了上面了后，点击相应月穿透
     * @param beginMonth 当前处理的月
     * @param startMonth 财年起始月
     * @return boolean
     * @author zcp
     * @date 2019/2/13 17:25
     * @since v1.0
     * @version v1.0
     */
    private static boolean checkIfSpanYear(int beginMonth, int startMonth) {
        //因为下半年beginMonth = startMonth + 6，即beginMonth有可能大于12
        int realMonth = beginMonth % 12;
        //12月%12 = 0
        realMonth = (realMonth == 0) ? 12 : realMonth;
        //如果位移的月份小于财年起始月，说明已经跨年。
        return realMonth < startMonth || (realMonth == startMonth && beginMonth > 12);
    }

    /**
     * 当从年、半年、季度筛选穿透进来时，因为小维度是月，所以要结合财年起始月，确定实际的自然年份
     * @param fromType   筛选的大维度
     * @param startMonth 财年起始月份
     * @param year       财年
     * @return java.lang.Integer
     * @author zcp
     * @date 2019/2/13 16:43
     * @since v1.0
     * @version v1.0
     */
    private static Integer formatYear4FromType(Integer fromType, int startMonth, Integer year) {
        //说明是从年、半年、季度筛选穿透进来
        boolean flag = (fromType != null)
                && (fromType.equals(TimeTypeEnum.YEAR.getCode())
                || fromType.equals(TimeTypeEnum.YEAR_HALF_UP.getCode())
                || fromType.equals(TimeTypeEnum.YEAR_HALF_DOWN.getCode())
                || fromType.equals(TimeTypeEnum.SEASON.getCode()));
        //财年起始月不为1月，则year财年为自然年+1，因此此时自然年是year-1
        if (flag && startMonth != 1) {
            year = (year - 1);
        }
        return year;
    }

    /**
     * 获取某年的1月1日0点 或者某年的最后一天截止
     * @param year 年份
     * @return java.lang.Integer 某年第一天0点时间戳
     * @author zcp
     * @date 2019/2/13 19:06
     * @since v1.0
     * @version v1.0
     */
    private static Integer getSomeDayOfYear(Integer year) {
        if (year == null || year == 0) {
            //当年
            return DateUtil.getFirstDateOfYear();
        }
        //某年
        Integer someday = DateUtil.getInt(String.valueOf(year) + "-01-01", new SimpleDateFormat("yyyy-MM-dd"));
        return someday;
    }

    /**
     * 某一月的第一天0点0分
     * @param month   某月
     * @param someday 某年某一天的时间戳
     * @return java.lang.Integer 某月第一天0点时间戳
     * @author zcp
     * @date 2019/2/13 19:10
     * @since v1.0
     * @version v1.0
     */
    private static Integer getFirstDateOfMonth(Integer month, Integer someday) {
        //本月月初
        Integer time = DateUtil.getFirstDateOfMonthInSomeday(DateUtil.getInt());
        if (month == null || month == 0) {
            month = StringUtil.toInt(DateUtil.getMonth(time));
        }
        int min = 1;
        int max = 12;
        //某一月
        if (month >= min && month <= max) {
            time = DateUtil.getFirstDateOfMonth(someday, month);
        }
        return time;
    }

    /**
     * 某一月的最后一天0点0分
     * @param month   某月
     * @param someday 某年某一天的时间戳
     * @return java.lang.Integer 某月最后一天0点时间戳
     * @author zcp
     * @date 2019/2/13 19:10
     * @since v1.0
     * @version v1.0
     */
    private static Integer getEndDateOfMonth(Integer month, Integer someday) {
        //本月月末
        Integer time = DateUtil.getLastDateOfMonthInSomeday(DateUtil.getInt());
        if (month == null || month == 0) {
            month = StringUtil.toInt(DateUtil.getMonth(DateUtil.getInt()));
        }
        int min = 1;
        int max = 12;
        //某一月
        if (month >= min && month <= max) {
            time = DateUtil.getEndDateOfMonth(someday, month);
        }
        return time;
    }

    /**
     * 筛选某一日
     * 目前主要是数据穿透用到
     * 注：timeType和fromType的关系
     * timeType:查看的业务的时间范围类型
     * fromType:点折线图内的某个数据时，如果大的时间范围是“年”，则图内单个数据展示的是“某月”；如果筛选的是“月/周”，则单个数据展示的是“某日”
     * 比如，筛选了3月的数据，然后点击了表格内3月8日的数据，则穿透时，timeType=1（代表日,结合month=3,day=8算具体时间）、fromType=3（筛选了月）
     * @param day      某天
     * @param year     年
     * @param fromType 筛选的大维度
     * @param month    月
     * @return java.lang.Integer 某天时间戳
     * @author zcp
     * @date 2019/2/13 19:14
     * @since v1.0
     * @version v1.0
     */
    private static Integer getSomeDay(Integer day, Integer year, Integer fromType, Integer month) {
        if (day == null || day == 0) {
            //本日
            return DateUtil.getTodayInt();
        }
        if (year == null || year == 0) {
            //当年
            year = StringUtil.toInt(DateUtil.getYear(DateUtil.getFirstDateOfYear()));
        }
        //month>0，则筛选某月
        //month=0，则首页“本月”，“上月”进入统计页
        if (month == 0 && fromType.equals(TimeTypeEnum.MONTH.getCode())) {
            month = StringUtil.toInt(DateUtil.getMonth(DateUtil.getInt()));
        } else if (month == 0 && fromType.equals(TimeTypeEnum.MONTH_LAST.getCode())) {
            month = StringUtil.toInt(DateUtil.getMonth(DateUtil.getFirstDateOfLastMonth()));
        }
        Integer time = DateUtil.getInt(year + "-" + month + "-" + day, new SimpleDateFormat("yyyy-MM-dd"));
        //某一天0点
        Integer startTime = DateUtil.getTodayInt(time);
        return startTime;
    }

    /**
     * 设置各个维度的开始结束时间，目前用到的有：全年、上下半年、季度
     *
     * @param startTimeList 方法getTimeList()的最终返回值之一，开始时间list
     * @param endTimeList   方法getTimeList()的最终返回值之一，结束时间list
     * @param flag          0正常的获取开始时间，1代表截至到某个时间、没有限定开始时间
     *                      注：flag默认为0，只有特殊的统计才是1，比如“客户总数分析”（截至当前时间）。。目前只有客户总数的该值是1
     * @param year          年份
     * @param startMonth    财年起始月
     * @param beginMonth    筛选的时间维度的开始月，例，全年、上半年从1月开始；下半年从7月开始；财年3月起始月，则财年下半年的起始月为9月
     * @param num           有多少个月，例：全年12、半年6、季度是3
     * @author zcp
     * @date 2019/2/13 20:02
     * @since v1.0
     * @version v1.0
     */
    private static void formatTime2Month(List<Integer> startTimeList, List<Integer> endTimeList, Integer flag, Integer year, int startMonth, int beginMonth, int num) {
        //是否需要对跨年加1，是否计算过
        boolean ifSpanAdd = false;
        if (startMonth == 1) {
            //说明财年设置的正常，不需要对year加
            ifSpanAdd = true;
        }
        //财年起始月不为1月，则year财年为自然年+1，因此此时自然年是year-1
        int yearTemp = (startMonth != 1) ? (year - 1) : year;
        Integer someday = DateUtil.getInt(yearTemp + "-01-01", new SimpleDateFormat("yyyy-MM-dd"));
        for (Integer i = 1; i <= num; i++) {
            if (!ifSpanAdd && checkIfSpanYear(beginMonth, startMonth)) {
                //跨年了，且没有计算过新的someday（计算过则无需再次计算）
                ifSpanAdd = true;
                yearTemp = yearTemp + 1;
                //下一年的某一天
                someday = DateUtil.getInt(yearTemp + "-01-01", new SimpleDateFormat("yyyy-MM-dd"));
            }
            //如果大于12，则%12
            beginMonth = (beginMonth > 12) ? beginMonth % 12 : beginMonth;
            if (flag == 0) {
                Integer startTime = getFirstDateOfMonth(beginMonth, someday);
                startTimeList.add(startTime);
            } else {
                startTimeList.add(-1);
            }
            Integer endTime = getEndDateOfMonth(beginMonth, someday);
            endTimeList.add(endTime);
            beginMonth++;
        }
    }

    /**
     * 把大时间维度气氛为天
     * @param startTimeList 开始时间list
     * @param endTimeList   结束时间list
     * @param flag          0正常的获取开始时间，1代表截至到某个时间、没有限定开始时间
     *                      注：flag默认为0，只有特殊的统计才是1，比如“客户总数分析”（截至当前时间）。。目前只有客户总数的该值是1
     * @param tempStartTime 开始时间
     * @param num           有多少天，如筛选一个月分n（n为endTime - startTime的结果除以86400）天、筛选一周分7天
     * @author zcp
     * @date 2019/2/13 20:09
     * @since v1.0
     * @version v1.0
     */
    private static void formatTime2Day(List<Integer> startTimeList, List<Integer> endTimeList, Integer flag, Integer tempStartTime, int num) {
        for (int i = 0; i < num; i++) {
            Integer startTime = tempStartTime + i * 86400;
            Integer endTime = startTime + 86400;
            if (flag == 0) {
                startTimeList.add(startTime);
            } else {
                startTimeList.add(-1);
            }
            endTimeList.add(endTime);
        }
    }

    /**
     * 获取财年内所有的周
     *
     * @param fiscalYear 财年
     * @param startMonth 财年起始月
     * @return List，财年内所有的周时间区间："07-02至07-08"，"07-09至07-15"，"07-16至07-22"...
     * @since performance-v1.0
     * @version performance-v1.0
     * @author cp.zhang
     * 创建时间：2018年8月21日 上午9:27:06
     * 修改时间：
     */
    public static List<String> getWeeks4Year(Integer fiscalYear, Integer startMonth) {
        //获取财年的起始、结束月份的int时间戳
        Integer fiscalStartTime = getFiscalYearStartInt(fiscalYear, startMonth);
        Integer fiscalEndTime = getFiscalYearEndInt(fiscalYear, startMonth);
        //从第1周开始
        Integer weekIndex = 1;
        //第1周的周一0点的时间
        Integer weekStartTime = DateUtil.getWeekStartTime(fiscalStartTime, weekIndex);

        Integer weekTime = 7 * 24 * 3600;
        //财年内所有的周时间区间："07-02至07-08"，"07-09至07-15"，"07-16至07-22"...
        List<String> weekPeriodList = new ArrayList<>();
        for (; ; weekIndex++) {
            if (weekStartTime > fiscalEndTime) {
                break;
            }
            //该周结束（因时间戳的截止时间是获取的下周一的0点，转化为string时要减一处理）
            Integer weekEndTime = weekStartTime + weekTime - 1;
            //该周开始
            String title = DateUtil.getString(weekStartTime, DateUtil.SDFMonthDay) + I18nMessageUtil.getMessage(CommonConstant.TO)
                    + DateUtil.getString(weekEndTime, DateUtil.SDFMonthDay);

            weekPeriodList.add(title);
            //下一周
            weekStartTime += weekTime;
        }
        return weekPeriodList;
    }

    /**
     * 获取财年内所有的周索引
     *
     * @param fiscalYear 财年
     * @param startMonth 财年起始月
     * @return List，财年内所有的周索引："w1"，"w2"，"w3"...
     * @since performance-v1.0
     * @version performance-v1.0
     * @author cp.zhang
     * 创建时间：2018年8月22日 下午2:47:43
     * 修改时间：
     */
    public static List<String> getWeekIndexs4Year(Integer fiscalYear, Integer startMonth) {
        //获取财年的起始、结束月份的int时间戳
        Integer fiscalStartTime = FiscalYearHelp.getFiscalYearStartInt(fiscalYear, startMonth);
        Integer fiscalEndTime = FiscalYearHelp.getFiscalYearEndInt(fiscalYear, startMonth);
        //从第1周开始
        Integer weekIndex = 1;
        //第1周的周一0点的时间
        Integer weekStartTime = DateUtil.getWeekStartTime(fiscalStartTime, weekIndex);

        Integer weekTime = 7 * 24 * 3600;
        //财年内所有的周索引："w1"，"w2"，"w3"...
        List<String> weekIndexList = new ArrayList<>();
        for (; ; weekIndex++) {
            if (weekStartTime > fiscalEndTime) {
                break;
            }
            String key = "w" + weekIndex;
            weekIndexList.add(key);
            weekStartTime += weekTime;
        }
        return weekIndexList;
    }

    /**
     * 财年内，某个月的所有的周索引："w6"，"w7，"w8"...
     * 封装周数据：只获取month月内的几个周
     *
     * @param fiscalStartTime 财年起始时间
     * @param monthStart      某个月的开始时间
     * @param monthEnd        某个月的结束时间
     * @return List，财年内，某个月的所有的周索引："w6"，"w7，"w8"...
     * @since performance-v1.0
     * @version performance-v1.0
     * @author cp.zhang
     * 创建时间：2018年8月22日 下午4:26:44
     * 修改时间：
     */
    public static List<String> getWeekIndex4Month(Integer fiscalStartTime, Integer monthStart, Integer monthEnd) {
        //month月的第一个周(也可能不在该月)
        int weekNum4Start = DateUtil.getWeekNum(fiscalStartTime, monthStart);
        //month月的最后一个周
        int weekNum4End = DateUtil.getWeekNum(fiscalStartTime, monthEnd);
        //第weekNum4Start周的周一0点的时间
        Integer weekStartTime4Start = DateUtil.getWeekStartTime(fiscalStartTime, weekNum4Start);
        //只获取month月的周，固不在本财年的不考虑（排除负数情况，即排除上财年的情况）
        weekNum4Start = (weekNum4Start < 0) ? 0 : weekNum4Start;
        //第weekNum4Start周的周一0点的时间不在该月，说明month月的第一个周是不属于该month的，后推一周
        if (weekStartTime4Start < monthStart) {
            //因为按照【周一在当前月份，则当周归属为该月，否则则归属到上一个月】的原则，第weekNum4Start周是属于month的上一个月的，往后平移一周
            weekNum4Start++;
        }
        //财年内，某个月的所有的周索引："w6"，"w7，"w8"...
        List<String> weekIndexList = new ArrayList<>();
        for (int i = weekNum4Start; i <= weekNum4End; i++) {
            weekIndexList.add("w" + i);
        }
        return weekIndexList;
    }
}
